home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 52 / Amiga Format AFCD52 (Issue 136, May 2000).iso / -serious- / programming / c / icu-1.3.1 / icu-bin / include / dtfmtsym.h < prev    next >
C/C++ Source or Header  |  2000-02-23  |  14KB  |  389 lines
  1. /*  
  2. ********************************************************************************
  3. *                                                                              *
  4. * COPYRIGHT:                                                                   *
  5. *   (C) Copyright Taligent, Inc.,  1997                                        *
  6. *   (C) Copyright International Business Machines Corporation,  1997-1999      *
  7. *   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
  8. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  9. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  10. *                                                                              *
  11. ********************************************************************************
  12. *
  13. * File DTFMTSYM.H
  14. *
  15. * Modification History:
  16. *
  17. *   Date        Name        Description
  18. *   02/19/97    aliu        Converted from java.
  19. *    07/21/98    stephen        Added getZoneIndex()
  20. *                            Changed to match C++ conventions
  21. ********************************************************************************
  22. */
  23.      
  24. #ifndef DTFMTSYM_H
  25. #define DTFMTSYM_H
  26.  
  27. #include "utypes.h"
  28. #include "locid.h"
  29.  
  30. /**
  31.  * DateFormatSymbols is a public class for encapsulating localizable date-time
  32.  * formatting data -- including timezone data. DateFormatSymbols is used by
  33.  * DateFormat and SimpleDateFormat.
  34.  * <P>
  35.  * Rather than first creating a DateFormatSymbols to get a date-time formatter
  36.  * by using a SimpleDateFormat constructor, clients are encouraged to create a
  37.  * date-time formatter using the getTimeInstance(), getDateInstance(), or
  38.  * getDateTimeInstance() method in DateFormat. Each of these methods can return a
  39.  * date/time formatter initialized with a default format pattern along with the
  40.  * date-time formatting data for a given or default locale. After a formatter is
  41.  * created, clients may modify the format pattern using the setPattern function
  42.  * as so desired. For more information on using these formatter factory
  43.  * functions, see DateFormat.
  44.  * <P>
  45.  * If clients decide to create a date-time formatter with a particular format
  46.  * pattern and locale, they can do so with new SimpleDateFormat(aPattern,
  47.  * new DateFormatSymbols(aLocale)).  This will load the appropriate date-time
  48.  * formatting data from the locale.
  49.  * <P>
  50.  * DateFormatSymbols objects are clonable. When clients obtain a
  51.  * DateFormatSymbols object, they can feel free to modify the date-time
  52.  * formatting data as necessary. For instance, clients can
  53.  * replace the localized date-time format pattern characters with the ones that
  54.  * they feel easy to remember. Or they can change the representative cities
  55.  * originally picked by default to using their favorite ones.
  56.  * <P>
  57.  * New DateFormatSymbols sub-classes may be added to support SimpleDateFormat
  58.  * for date-time formatting for additional locales.
  59.  */
  60. class U_I18N_API DateFormatSymbols {
  61. public:
  62.     /**
  63.      * Construct a DateFormatSymbols object by loading format data from
  64.      * resources for the default locale.
  65.      * <P>
  66.      * NOTE: This constructor will never fail; if it cannot get resource
  67.      * data for the default locale, it will return a last-resort object
  68.      * based on hard-coded strings.
  69.      *
  70.      * @param status    Output param set to success of failure.  Failure
  71.      *                  results if the resources for the default cannot be
  72.      *                  found or cannot be loaded
  73.      */
  74.     DateFormatSymbols(UErrorCode& status);
  75.  
  76.     /**
  77.      * Construct a DateFormatSymbols object by loading format data from
  78.      * resources for the given locale.
  79.      *
  80.      * @param locale    Locale to load format data from.
  81.      * @param status    Output param set to success of failure.  Failure
  82.      *                  results if the resources for the locale cannot be
  83.      *                  found or cannot be loaded
  84.      */
  85.     DateFormatSymbols(const Locale& locale,
  86.                       UErrorCode& status);
  87.  
  88.     /**
  89.      * Copy constructor.
  90.      */
  91.     DateFormatSymbols(const DateFormatSymbols&);
  92.  
  93.     /**
  94.      * Assignment operator.
  95.      */
  96.     DateFormatSymbols& operator=(const DateFormatSymbols&);
  97.  
  98.     /**
  99.      * Destructor. This is nonvirtual because this class is not designed to be
  100.      * subclassed.
  101.      */
  102.     ~DateFormatSymbols();
  103.  
  104.     /**
  105.      * Return true if another object is semantically equal to this one.
  106.      */
  107.     bool_t operator==(const DateFormatSymbols& other) const;
  108.  
  109.     /**
  110.      * Return true if another object is semantically unequal to this one.
  111.      */
  112.     bool_t operator!=(const DateFormatSymbols& other) const { return !operator==(other); }
  113.  
  114.     /**
  115.      * Gets era strings. For example: "AD" and "BC".
  116.      * @return the era strings.
  117.      */
  118.     const UnicodeString* getEras(int32_t& count) const;
  119.  
  120.     /**
  121.      * Sets era strings. For example: "AD" and "BC".
  122.      * @param eras  Array of era strings (DateFormatSymbols retains ownership.)
  123.      * @param count Filled in with length of the array.
  124.      */
  125.     void setEras(const UnicodeString* eras, int32_t count);
  126.  
  127.     /**
  128.      * Gets month strings. For example: "January", "February", etc.
  129.      * @param count Filled in with length of the array.
  130.      * @return the month strings. (DateFormatSymbols retains ownership.)
  131.      */
  132.     const UnicodeString* getMonths(int32_t& count) const;
  133.  
  134.     /**
  135.      * Sets month strings. For example: "January", "February", etc.
  136.      * @param newMonths the new month strings. (not adopted; caller retains ownership)
  137.      */
  138.     void setMonths(const UnicodeString* months, int32_t count);
  139.  
  140.     /**
  141.      * Gets short month strings. For example: "Jan", "Feb", etc.
  142.      * @return the short month strings. (DateFormatSymbols retains ownership.)
  143.      */
  144.     const UnicodeString* getShortMonths(int32_t& count) const;
  145.  
  146.     /**
  147.      * Sets short month strings. For example: "Jan", "Feb", etc.
  148.      * @param newShortMonths the new short month strings. (not adopted; caller retains ownership)
  149.      */
  150.     void setShortMonths(const UnicodeString* shortMonths, int32_t count);
  151.  
  152.     /**
  153.      * Gets weekday strings. For example: "Sunday", "Monday", etc.
  154.      * @return the weekday strings. (DateFormatSymbols retains ownership.)
  155.      */
  156.     const UnicodeString* getWeekdays(int32_t& count) const;
  157.  
  158.     /**
  159.      * Sets weekday strings. For example: "Sunday", "Monday", etc.
  160.      * @param newWeekdays the new weekday strings. (not adopted; caller retains ownership)
  161.      */
  162.     void setWeekdays(const UnicodeString* weekdays, int32_t count);
  163.  
  164.     /**
  165.      * Gets short weekday strings. For example: "Sun", "Mon", etc.
  166.      * @return the short weekday strings. (DateFormatSymbols retains ownership.)
  167.      */
  168.     const UnicodeString* getShortWeekdays(int32_t& count) const;
  169.  
  170.     /**
  171.      * Sets short weekday strings. For example: "Sun", "Mon", etc.
  172.      * @param newShortWeekdays the new short weekday strings. (not adopted; caller retains ownership)
  173.      */
  174.     void setShortWeekdays(const UnicodeString* shortWeekdays, int32_t count);
  175.  
  176.     /**
  177.      * Gets AM/PM strings. For example: "AM" and "PM".
  178.      * @return the weekday strings. (DateFormatSymbols retains ownership.)
  179.      */
  180.     const UnicodeString* getAmPmStrings(int32_t& count) const;
  181.  
  182.     /**
  183.      * Sets ampm strings. For example: "AM" and "PM".
  184.      * @param newAmpms the new ampm strings. (not adopted; caller retains ownership)
  185.      */
  186.     void setAmPmStrings(const UnicodeString* ampms, int32_t count);
  187.  
  188.     /**
  189.      * Gets timezone strings. These strings are stored in a 2-dimensional array.
  190.      * @param rowCount      Output param to receive number of rows.
  191.      * @param columnCount   Output param to receive number of columns.
  192.      * @return              The timezone strings as a 2-d array. (DateFormatSymbols retains ownership.)
  193.      */
  194.     const UnicodeString** getZoneStrings(int32_t& rowCount, int32_t& columnCount) const;
  195.  
  196.     /**
  197.      * Sets timezone strings. These strings are stored in a 2-dimensional array.
  198.      * @param strings       The timezone strings as a 2-d array to be copied. (not adopted; caller retains ownership)
  199.      * @param rowCount      The number of rows (count of first index).
  200.      * @param columnCount   The number of columns (count of second index).
  201.      */
  202.     void setZoneStrings(const UnicodeString* const* strings, int32_t rowCount, int32_t columnCount);
  203.  
  204.     /**
  205.      * Get the non-localized date-time pattern characters.
  206.      */
  207.     static const UnicodeString& getPatternChars(void) { return fgPatternChars; }
  208.  
  209.     /**
  210.      * Gets localized date-time pattern characters. For example: 'u', 't', etc.
  211.      * @return the localized date-time pattern characters.
  212.      */
  213.     UnicodeString& getLocalPatternChars(UnicodeString& result) const;
  214.  
  215.     /**
  216.      * Sets localized date-time pattern characters. For example: 'u', 't', etc.
  217.      * @param newLocalPatternChars the new localized date-time
  218.      * pattern characters.
  219.      */
  220.     void setLocalPatternChars(const UnicodeString& newLocalPatternChars);
  221.  
  222. private:
  223.     friend class SimpleDateFormat;
  224.  
  225.     /**
  226.      * Era strings. For example: "AD" and "BC".
  227.      */
  228.     UnicodeString*  fEras;
  229.     int32_t         fErasCount;
  230.  
  231.     /**
  232.      * Month strings. For example: "January", "February", etc.
  233.      */
  234.     UnicodeString*  fMonths;
  235.     int32_t         fMonthsCount;
  236.  
  237.     /**
  238.      * Short month strings. For example: "Jan", "Feb", etc.
  239.      */
  240.     UnicodeString*  fShortMonths;
  241.     int32_t         fShortMonthsCount;
  242.  
  243.     /**
  244.      * Weekday strings. For example: "Sunday", "Monday", etc.
  245.      */
  246.     UnicodeString*  fWeekdays;
  247.     int32_t         fWeekdaysCount;
  248.  
  249.     /**
  250.      * Short weekday strings. For example: "Sun", "Mon", etc.
  251.      */
  252.     UnicodeString*  fShortWeekdays;
  253.     int32_t         fShortWeekdaysCount;
  254.  
  255.     /**
  256.      * Ampm strings. For example: "AM" and "PM".
  257.      */
  258.     UnicodeString*  fAmPms;
  259.     int32_t         fAmPmsCount;
  260.  
  261.     /**
  262.      * The format data of all the timezones in this locale.
  263.      */
  264.     UnicodeString** fZoneStrings;
  265.     int32_t         fZoneStringsRowCount;
  266.     int32_t         fZoneStringsColCount;
  267.  
  268.     /**
  269.      * Localized date-time pattern characters. For example: use 'u' as 'y'.
  270.      */
  271.     UnicodeString   fLocalPatternChars;
  272.  
  273.     /**
  274.      * Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All
  275.      * locales use the same these unlocalized pattern characters.
  276.      */
  277.     static UnicodeString fgPatternChars;
  278.  
  279. private:
  280.     /**
  281.      * Called by the constructors to actually load data from the resources
  282.      */
  283.     void initializeData(const Locale&, UErrorCode& status, bool_t useLastResortData = FALSE);
  284.  
  285.     /**
  286.      * Copy or alias an array in another object, as appropriate.
  287.      */
  288.     void assignArray(UnicodeString*& dstArray,
  289.                      int32_t& dstCount,
  290.                      const UnicodeString* srcArray,
  291.                      int32_t srcCount,
  292.                      const DateFormatSymbols& other,
  293.                      int32_t which);
  294.  
  295.     /**
  296.      * Return true if the given arrays' contents are equal, or if the arrays are
  297.      * identical (pointers are equal).
  298.      */
  299.     static bool_t arrayCompare(const UnicodeString* array1,
  300.                              const UnicodeString* array2,
  301.                              int32_t count);
  302.  
  303.     /**
  304.      * Create a copy, in fZoneStrings, of the given zone strings array. The
  305.      * member variables fZoneStringsRowCount and fZoneStringsColCount should be
  306.      * set already by the caller. The fIsOwned flags are not checked or set by
  307.      * this method; that is the caller's responsibility.
  308.      */
  309.     void createZoneStrings(const UnicodeString *const * otherStrings);
  310.  
  311.     /**
  312.      * Package private: used by SimpleDateFormat
  313.      * Gets the index for the given time zone ID to obtain the timezone
  314.      * strings for formatting. The time zone ID is just for programmatic
  315.      * lookup. NOT LOCALIZED!!!
  316.      * @param ID the given time zone ID.
  317.      * @return the index of the given time zone ID.  Returns -1 if
  318.      * the given time zone ID can't be located in the DateFormatSymbols object.
  319.      * @see java.util.SimpleTimeZone
  320.      */
  321.     int32_t getZoneIndex(const UnicodeString& ID) const;
  322.  
  323.     /**
  324.      * Delete all the storage owned by this object and reset the fIsOwned flag
  325.      * to indicate that arrays have been deleted.
  326.      */
  327.     void dispose(void);
  328.  
  329.     /**
  330.      * Delete just the zone strings, if they are owned by this object. This
  331.      * method does NOT modify fIsOwned; the caller must handle that.
  332.      */
  333.     void disposeZoneStrings(void);
  334.  
  335.     /**
  336.      * These are static arrays we use only in the case where we have no
  337.      * resource data.
  338.      */
  339.     static const UnicodeString     fgLastResortMonthNames[];
  340.     static const UnicodeString     fgLastResortDayNames[];
  341.     static const UnicodeString     fgLastResortAmPmMarkers[];
  342.     static const UnicodeString     fgLastResortEras[];
  343.     static const UnicodeString     fgLastResortZoneStrings[];
  344.     static UnicodeString**         fgLastResortZoneStringsH;
  345.  
  346.     /**
  347.      * The member fIsOwned is a bit field with flags indicating which of the arrays
  348.      * we own. This is necessary since the user may alter our symbols, but in
  349.      * most cases, will not, so we do not want to copy these arrays unless
  350.      * necessary.
  351.      */
  352.     enum
  353.     {
  354.         kEras,
  355.         kMonths,
  356.         kShortMonths,
  357.         kWeekdays,
  358.         kShortWeekdays,
  359.         kAmPms,
  360.         kZoneStrings
  361.     };
  362.     uint8_t                 fIsOwned;
  363.  
  364.     /**
  365.      * Sets the fIsOwned flag for the specfied string array
  366.      */
  367.     void                    setIsOwned(int32_t which, bool_t isOwned);
  368.  
  369.     /**
  370.      * Tests the fIsOwned flag for the specified string array
  371.      */
  372.     bool_t                  isOwned(int32_t which) const;
  373. };
  374.  
  375. inline void
  376. DateFormatSymbols::setIsOwned(int32_t which, bool_t isOwned)
  377. {
  378.     fIsOwned = ( fIsOwned & ~(1 << which) ) | ( (isOwned ? 1 : 0) << which );
  379. }
  380.  
  381. inline bool_t
  382. DateFormatSymbols::isOwned(int32_t which) const
  383. {
  384.     return ( (fIsOwned >> which) & 1 ) != 0;
  385. }
  386.  
  387. #endif // _DTFMTSYM
  388. //eof
  389.